home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / DB / mysql.php < prev    next >
PHP Script  |  2004-10-01  |  29KB  |  917 lines
  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2004 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Author: Stig Bakken <ssb@php.net>                                    |
  17. // | Maintainer: Daniel Convissor <danielc@php.net>                       |
  18. // +----------------------------------------------------------------------+
  19. //
  20. // $Id: mysql.php,v 1.74 2004/04/29 22:42:57 danielc Exp $
  21.  
  22.  
  23. // XXX legend:
  24. //
  25. // XXX ERRORMSG: The error message from the mysql function should
  26. //               be registered here.
  27. //
  28. // TODO/wishlist:
  29. // longReadlen
  30. // binmode
  31.  
  32.  
  33. require_once 'DB/common.php';
  34.  
  35. /**
  36.  * Database independent query interface definition for PHP's MySQL
  37.  * extension.
  38.  *
  39.  * This is for MySQL versions 4.0 and below.
  40.  *
  41.  * @package  DB
  42.  * @version  $Id: mysql.php,v 1.74 2004/04/29 22:42:57 danielc Exp $
  43.  * @category Database
  44.  * @author   Stig Bakken <ssb@php.net>
  45.  */
  46. class DB_mysql extends DB_common
  47. {
  48.     // {{{ properties
  49.  
  50.     var $connection;
  51.     var $phptype, $dbsyntax;
  52.     var $prepare_tokens = array();
  53.     var $prepare_types = array();
  54.     var $num_rows = array();
  55.     var $transaction_opcount = 0;
  56.     var $autocommit = true;
  57.     var $fetchmode = DB_FETCHMODE_ORDERED; /* Default fetch mode */
  58.     var $_db = false;
  59.  
  60.     // }}}
  61.     // {{{ constructor
  62.  
  63.     /**
  64.      * DB_mysql constructor.
  65.      *
  66.      * @access public
  67.      */
  68.     function DB_mysql()
  69.     {
  70.         $this->DB_common();
  71.         $this->phptype = 'mysql';
  72.         $this->dbsyntax = 'mysql';
  73.         $this->features = array(
  74.             'prepare' => false,
  75.             'pconnect' => true,
  76.             'transactions' => true,
  77.             'limit' => 'alter'
  78.         );
  79.         $this->errorcode_map = array(
  80.             1004 => DB_ERROR_CANNOT_CREATE,
  81.             1005 => DB_ERROR_CANNOT_CREATE,
  82.             1006 => DB_ERROR_CANNOT_CREATE,
  83.             1007 => DB_ERROR_ALREADY_EXISTS,
  84.             1008 => DB_ERROR_CANNOT_DROP,
  85.             1022 => DB_ERROR_ALREADY_EXISTS,
  86.             1046 => DB_ERROR_NODBSELECTED,
  87.             1048 => DB_ERROR_CONSTRAINT,
  88.             1050 => DB_ERROR_ALREADY_EXISTS,
  89.             1051 => DB_ERROR_NOSUCHTABLE,
  90.             1054 => DB_ERROR_NOSUCHFIELD,
  91.             1062 => DB_ERROR_ALREADY_EXISTS,
  92.             1064 => DB_ERROR_SYNTAX,
  93.             1100 => DB_ERROR_NOT_LOCKED,
  94.             1136 => DB_ERROR_VALUE_COUNT_ON_ROW,
  95.             1146 => DB_ERROR_NOSUCHTABLE,
  96.             1216 => DB_ERROR_CONSTRAINT,
  97.             1217 => DB_ERROR_CONSTRAINT,
  98.         );
  99.     }
  100.  
  101.     // }}}
  102.     // {{{ connect()
  103.  
  104.     /**
  105.      * Connect to a database and log in as the specified user.
  106.      *
  107.      * @param $dsn the data source name (see DB::parseDSN for syntax)
  108.      * @param $persistent (optional) whether the connection should
  109.      *        be persistent
  110.      * @access public
  111.      * @return int DB_OK on success, a DB error on failure
  112.      */
  113.     function connect($dsninfo, $persistent = false)
  114.     {
  115.         if (!DB::assertExtension('mysql')) {
  116.             return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
  117.         }
  118.         $this->dsn = $dsninfo;
  119.         if ($dsninfo['protocol'] && $dsninfo['protocol'] == 'unix') {
  120.             $dbhost = ':' . $dsninfo['socket'];
  121.         } else {
  122.             $dbhost = $dsninfo['hostspec'] ? $dsninfo['hostspec'] : 'localhost';
  123.             if ($dsninfo['port']) {
  124.                 $dbhost .= ':' . $dsninfo['port'];
  125.             }
  126.         }
  127.  
  128.         $connect_function = $persistent ? 'mysql_pconnect' : 'mysql_connect';
  129.  
  130.         if ($dbhost && $dsninfo['username'] && isset($dsninfo['password'])) {
  131.             $conn = @$connect_function($dbhost, $dsninfo['username'],
  132.                                        $dsninfo['password']);
  133.         } elseif ($dbhost && $dsninfo['username']) {
  134.             $conn = @$connect_function($dbhost, $dsninfo['username']);
  135.         } elseif ($dbhost) {
  136.             $conn = @$connect_function($dbhost);
  137.         } else {
  138.             $conn = false;
  139.         }
  140.         if (!$conn) {
  141.             if (($err = @mysql_error()) != '') {
  142.                 return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
  143.                                          null, $err);
  144.             } elseif (empty($php_errormsg)) {
  145.                 return $this->raiseError(DB_ERROR_CONNECT_FAILED);
  146.             } else {
  147.                 return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
  148.                                          null, $php_errormsg);
  149.             }
  150.         }
  151.  
  152.         if ($dsninfo['database']) {
  153.             if (!@mysql_select_db($dsninfo['database'], $conn)) {
  154.                switch(mysql_errno($conn)) {
  155.                         case 1049:
  156.                             return $this->raiseError(DB_ERROR_NOSUCHDB, null, null,
  157.                                                      null, @mysql_error($conn));
  158.                         case 1044:
  159.                              return $this->raiseError(DB_ERROR_ACCESS_VIOLATION, null, null,
  160.                                                       null, @mysql_error($conn));
  161.                         default:
  162.                             return $this->raiseError(DB_ERROR, null, null,
  163.                                                      null, @mysql_error($conn));
  164.                     }
  165.             }
  166.             // fix to allow calls to different databases in the same script
  167.             $this->_db = $dsninfo['database'];
  168.         }
  169.  
  170.         $this->connection = $conn;
  171.         return DB_OK;
  172.     }
  173.  
  174.     // }}}
  175.     // {{{ disconnect()
  176.  
  177.     /**
  178.      * Log out and disconnect from the database.
  179.      *
  180.      * @access public
  181.      *
  182.      * @return bool true on success, false if not connected.
  183.      */
  184.     function disconnect()
  185.     {
  186.         $ret = @mysql_close($this->connection);
  187.         $this->connection = null;
  188.         return $ret;
  189.     }
  190.  
  191.     // }}}
  192.     // {{{ simpleQuery()
  193.  
  194.     /**
  195.      * Send a query to MySQL and return the results as a MySQL resource
  196.      * identifier.
  197.      *
  198.      * @param the SQL query
  199.      *
  200.      * @access public
  201.      *
  202.      * @return mixed returns a valid MySQL result for successful SELECT
  203.      * queries, DB_OK for other successful queries.  A DB error is
  204.      * returned on failure.
  205.      */
  206.     function simpleQuery($query)
  207.     {
  208.         $ismanip = DB::isManip($query);
  209.         $this->last_query = $query;
  210.         $query = $this->modifyQuery($query);
  211.         if ($this->_db) {
  212.             if (!@mysql_select_db($this->_db, $this->connection)) {
  213.                 return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
  214.             }
  215.         }
  216.         if (!$this->autocommit && $ismanip) {
  217.             if ($this->transaction_opcount == 0) {
  218.                 $result = @mysql_query('SET AUTOCOMMIT=0', $this->connection);
  219.                 $result = @mysql_query('BEGIN', $this->connection);
  220.                 if (!$result) {
  221.                     return $this->mysqlRaiseError();
  222.                 }
  223.             }
  224.             $this->transaction_opcount++;
  225.         }
  226.         $result = @mysql_query($query, $this->connection);
  227.         if (!$result) {
  228.             return $this->mysqlRaiseError();
  229.         }
  230.         if (is_resource($result)) {
  231.             $numrows = $this->numrows($result);
  232.             if (is_object($numrows)) {
  233.                 return $numrows;
  234.             }
  235.             $this->num_rows[(int)$result] = $numrows;
  236.             return $result;
  237.         }
  238.         return DB_OK;
  239.     }
  240.  
  241.     // }}}
  242.     // {{{ nextResult()
  243.  
  244.     /**
  245.      * Move the internal mysql result pointer to the next available result
  246.      *
  247.      * This method has not been implemented yet.
  248.      *
  249.      * @param a valid sql result resource
  250.      *
  251.      * @access public
  252.      *
  253.      * @return false
  254.      */
  255.     function nextResult($result)
  256.     {
  257.         return false;
  258.     }
  259.  
  260.     // }}}
  261.     // {{{ fetchInto()
  262.  
  263.     /**
  264.      * Fetch a row and insert the data into an existing array.
  265.      *
  266.      * Formating of the array and the data therein are configurable.
  267.      * See DB_result::fetchInto() for more information.
  268.      *
  269.      * @param resource $result    query result identifier
  270.      * @param array    $arr       (reference) array where data from the row
  271.      *                            should be placed
  272.      * @param int      $fetchmode how the resulting array should be indexed
  273.      * @param int      $rownum    the row number to fetch
  274.      *
  275.      * @return mixed DB_OK on success, null when end of result set is
  276.      *               reached or on failure
  277.      *
  278.      * @see DB_result::fetchInto()
  279.      * @access private
  280.      */
  281.     function fetchInto($result, &$arr, $fetchmode, $rownum=null)
  282.     {
  283.         if ($rownum !== null) {
  284.             if (!@mysql_data_seek($result, $rownum)) {
  285.                 return null;
  286.             }
  287.         }
  288.         if ($fetchmode & DB_FETCHMODE_ASSOC) {
  289.             $arr = @mysql_fetch_array($result, MYSQL_ASSOC);
  290.             if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
  291.                 $arr = array_change_key_case($arr, CASE_LOWER);
  292.             }
  293.         } else {
  294.             $arr = @mysql_fetch_row($result);
  295.         }
  296.         if (!$arr) {
  297.             // See: http://bugs.php.net/bug.php?id=22328
  298.             // for why we can't check errors on fetching
  299.             return null;
  300.             /*
  301.             $errno = @mysql_errno($this->connection);
  302.             if (!$errno) {
  303.                 return null;
  304.             }
  305.             return $this->mysqlRaiseError($errno);
  306.             */
  307.         }
  308.         if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
  309.             /*
  310.              * Even though this DBMS already trims output, we do this because
  311.              * a field might have intentional whitespace at the end that
  312.              * gets removed by DB_PORTABILITY_RTRIM under another driver.
  313.              */
  314.             $this->_rtrimArrayValues($arr);
  315.         }
  316.         if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
  317.             $this->_convertNullArrayValuesToEmpty($arr);
  318.         }
  319.         return DB_OK;
  320.     }
  321.  
  322.     // }}}
  323.     // {{{ freeResult()
  324.  
  325.     /**
  326.      * Free the internal resources associated with $result.
  327.      *
  328.      * @param $result MySQL result identifier
  329.      *
  330.      * @access public
  331.      *
  332.      * @return bool true on success, false if $result is invalid
  333.      */
  334.     function freeResult($result)
  335.     {
  336.         unset($this->num_rows[(int)$result]);
  337.         return @mysql_free_result($result);
  338.     }
  339.  
  340.     // }}}
  341.     // {{{ numCols()
  342.  
  343.     /**
  344.      * Get the number of columns in a result set.
  345.      *
  346.      * @param $result MySQL result identifier
  347.      *
  348.      * @access public
  349.      *
  350.      * @return int the number of columns per row in $result
  351.      */
  352.     function numCols($result)
  353.     {
  354.         $cols = @mysql_num_fields($result);
  355.  
  356.         if (!$cols) {
  357.             return $this->mysqlRaiseError();
  358.         }
  359.  
  360.         return $cols;
  361.     }
  362.  
  363.     // }}}
  364.     // {{{ numRows()
  365.  
  366.     /**
  367.      * Get the number of rows in a result set.
  368.      *
  369.      * @param $result MySQL result identifier
  370.      *
  371.      * @access public
  372.      *
  373.      * @return int the number of rows in $result
  374.      */
  375.     function numRows($result)
  376.     {
  377.         $rows = @mysql_num_rows($result);
  378.         if ($rows === null) {
  379.             return $this->mysqlRaiseError();
  380.         }
  381.         return $rows;
  382.     }
  383.  
  384.     // }}}
  385.     // {{{ autoCommit()
  386.  
  387.     /**
  388.      * Enable/disable automatic commits
  389.      */
  390.     function autoCommit($onoff = false)
  391.     {
  392.         // XXX if $this->transaction_opcount > 0, we should probably
  393.         // issue a warning here.
  394.         $this->autocommit = $onoff ? true : false;
  395.         return DB_OK;
  396.     }
  397.  
  398.     // }}}
  399.     // {{{ commit()
  400.  
  401.     /**
  402.      * Commit the current transaction.
  403.      */
  404.     function commit()
  405.     {
  406.         if ($this->transaction_opcount > 0) {
  407.             if ($this->_db) {
  408.                 if (!@mysql_select_db($this->_db, $this->connection)) {
  409.                     return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
  410.                 }
  411.             }
  412.             $result = @mysql_query('COMMIT', $this->connection);
  413.             $result = @mysql_query('SET AUTOCOMMIT=1', $this->connection);
  414.             $this->transaction_opcount = 0;
  415.             if (!$result) {
  416.                 return $this->mysqlRaiseError();
  417.             }
  418.         }
  419.         return DB_OK;
  420.     }
  421.  
  422.     // }}}
  423.     // {{{ rollback()
  424.  
  425.     /**
  426.      * Roll back (undo) the current transaction.
  427.      */
  428.     function rollback()
  429.     {
  430.         if ($this->transaction_opcount > 0) {
  431.             if ($this->_db) {
  432.                 if (!@mysql_select_db($this->_db, $this->connection)) {
  433.                     return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
  434.                 }
  435.             }
  436.             $result = @mysql_query('ROLLBACK', $this->connection);
  437.             $result = @mysql_query('SET AUTOCOMMIT=1', $this->connection);
  438.             $this->transaction_opcount = 0;
  439.             if (!$result) {
  440.                 return $this->mysqlRaiseError();
  441.             }
  442.         }
  443.         return DB_OK;
  444.     }
  445.  
  446.     // }}}
  447.     // {{{ affectedRows()
  448.  
  449.     /**
  450.      * Gets the number of rows affected by the data manipulation
  451.      * query.  For other queries, this function returns 0.
  452.      *
  453.      * @return number of rows affected by the last query
  454.      */
  455.     function affectedRows()
  456.     {
  457.         if (DB::isManip($this->last_query)) {
  458.             return @mysql_affected_rows($this->connection);
  459.         } else {
  460.             return 0;
  461.         }
  462.      }
  463.  
  464.     // }}}
  465.     // {{{ errorNative()
  466.  
  467.     /**
  468.      * Get the native error code of the last error (if any) that
  469.      * occured on the current connection.
  470.      *
  471.      * @access public
  472.      *
  473.      * @return int native MySQL error code
  474.      */
  475.     function errorNative()
  476.     {
  477.         return @mysql_errno($this->connection);
  478.     }
  479.  
  480.     // }}}
  481.     // {{{ nextId()
  482.  
  483.     /**
  484.      * Returns the next free id in a sequence
  485.      *
  486.      * @param string  $seq_name  name of the sequence
  487.      * @param boolean $ondemand  when true, the seqence is automatically
  488.      *                           created if it does not exist
  489.      *
  490.      * @return int  the next id number in the sequence.  DB_Error if problem.
  491.      *
  492.      * @internal
  493.      * @see DB_common::nextID()
  494.      * @access public
  495.      */
  496.     function nextId($seq_name, $ondemand = true)
  497.     {
  498.         $seqname = $this->getSequenceName($seq_name);
  499.         do {
  500.             $repeat = 0;
  501.             $this->pushErrorHandling(PEAR_ERROR_RETURN);
  502.             $result = $this->query("UPDATE ${seqname} ".
  503.                                    'SET id=LAST_INSERT_ID(id+1)');
  504.             $this->popErrorHandling();
  505.             if ($result === DB_OK) {
  506.                 /** COMMON CASE **/
  507.                 $id = @mysql_insert_id($this->connection);
  508.                 if ($id != 0) {
  509.                     return $id;
  510.                 }
  511.                 /** EMPTY SEQ TABLE **/
  512.                 // Sequence table must be empty for some reason, so fill it and return 1
  513.                 // Obtain a user-level lock
  514.                 $result = $this->getOne("SELECT GET_LOCK('${seqname}_lock',10)");
  515.                 if (DB::isError($result)) {
  516.                     return $this->raiseError($result);
  517.                 }
  518.                 if ($result == 0) {
  519.                     // Failed to get the lock, bail with a DB_ERROR_NOT_LOCKED error
  520.                     return $this->mysqlRaiseError(DB_ERROR_NOT_LOCKED);
  521.                 }
  522.  
  523.                 // add the default value
  524.                 $result = $this->query("REPLACE INTO ${seqname} (id) VALUES (0)");
  525.                 if (DB::isError($result)) {
  526.                     return $this->raiseError($result);
  527.                 }
  528.  
  529.                 // Release the lock
  530.                 $result = $this->getOne("SELECT RELEASE_LOCK('${seqname}_lock')");
  531.                 if (DB::isError($result)) {
  532.                     return $this->raiseError($result);
  533.                 }
  534.                 // We know what the result will be, so no need to try again
  535.                 return 1;
  536.  
  537.             /** ONDEMAND TABLE CREATION **/
  538.             } elseif ($ondemand && DB::isError($result) &&
  539.                 $result->getCode() == DB_ERROR_NOSUCHTABLE)
  540.             {
  541.                 $result = $this->createSequence($seq_name);
  542.                 if (DB::isError($result)) {
  543.                     return $this->raiseError($result);
  544.                 } else {
  545.                     $repeat = 1;
  546.                 }
  547.  
  548.             /** BACKWARDS COMPAT **/
  549.             } elseif (DB::isError($result) &&
  550.                       $result->getCode() == DB_ERROR_ALREADY_EXISTS)
  551.             {
  552.                 // see _BCsequence() comment
  553.                 $result = $this->_BCsequence($seqname);
  554.                 if (DB::isError($result)) {
  555.                     return $this->raiseError($result);
  556.                 }
  557.                 $repeat = 1;
  558.             }
  559.         } while ($repeat);
  560.  
  561.         return $this->raiseError($result);
  562.     }
  563.  
  564.     // }}}
  565.     // {{{ createSequence()
  566.  
  567.     /**
  568.      * Creates a new sequence
  569.      *
  570.      * @param string $seq_name  name of the new sequence
  571.      *
  572.      * @return int  DB_OK on success.  A DB_Error object is returned if
  573.      *              problems arise.
  574.      *
  575.      * @internal
  576.      * @see DB_common::createSequence()
  577.      * @access public
  578.      */
  579.     function createSequence($seq_name)
  580.     {
  581.         $seqname = $this->getSequenceName($seq_name);
  582.         $res = $this->query("CREATE TABLE ${seqname} ".
  583.                             '(id INTEGER UNSIGNED AUTO_INCREMENT NOT NULL,'.
  584.                             ' PRIMARY KEY(id))');
  585.         if (DB::isError($res)) {
  586.             return $res;
  587.         }
  588.         // insert yields value 1, nextId call will generate ID 2
  589.         $res = $this->query("INSERT INTO ${seqname} (id) VALUES (0)");
  590.         if (DB::isError($res)) {
  591.             return $res;
  592.         }
  593.         // so reset to zero
  594.         return $this->query("UPDATE ${seqname} SET id = 0;");
  595.     }
  596.  
  597.     // }}}
  598.     // {{{ dropSequence()
  599.  
  600.     /**
  601.      * Deletes a sequence
  602.      *
  603.      * @param string $seq_name  name of the sequence to be deleted
  604.      *
  605.      * @return int  DB_OK on success.  DB_Error if problems.
  606.      *
  607.      * @internal
  608.      * @see DB_common::dropSequence()
  609.      * @access public
  610.      */
  611.     function dropSequence($seq_name)
  612.     {
  613.         return $this->query('DROP TABLE ' . $this->getSequenceName($seq_name));
  614.     }
  615.  
  616.     // }}}
  617.     // {{{ _BCsequence()
  618.  
  619.     /**
  620.      * Backwards compatibility with old sequence emulation implementation
  621.      * (clean up the dupes)
  622.      *
  623.      * @param string $seqname The sequence name to clean up
  624.      * @return mixed DB_Error or true
  625.      */
  626.     function _BCsequence($seqname)
  627.     {
  628.         // Obtain a user-level lock... this will release any previous
  629.         // application locks, but unlike LOCK TABLES, it does not abort
  630.         // the current transaction and is much less frequently used.
  631.         $result = $this->getOne("SELECT GET_LOCK('${seqname}_lock',10)");
  632.         if (DB::isError($result)) {
  633.             return $result;
  634.         }
  635.         if ($result == 0) {
  636.             // Failed to get the lock, can't do the conversion, bail
  637.             // with a DB_ERROR_NOT_LOCKED error
  638.             return $this->mysqlRaiseError(DB_ERROR_NOT_LOCKED);
  639.         }
  640.  
  641.         $highest_id = $this->getOne("SELECT MAX(id) FROM ${seqname}");
  642.         if (DB::isError($highest_id)) {
  643.             return $highest_id;
  644.         }
  645.         // This should kill all rows except the highest
  646.         // We should probably do something if $highest_id isn't
  647.         // numeric, but I'm at a loss as how to handle that...
  648.         $result = $this->query("DELETE FROM ${seqname} WHERE id <> $highest_id");
  649.         if (DB::isError($result)) {
  650.             return $result;
  651.         }
  652.  
  653.         // If another thread has been waiting for this lock,
  654.         // it will go thru the above procedure, but will have no
  655.         // real effect
  656.         $result = $this->getOne("SELECT RELEASE_LOCK('${seqname}_lock')");
  657.         if (DB::isError($result)) {
  658.             return $result;
  659.         }
  660.         return true;
  661.     }
  662.  
  663.     // }}}
  664.     // {{{ quoteIdentifier()
  665.  
  666.     /**
  667.      * Quote a string so it can be safely used as a table or column name
  668.      *
  669.      * Quoting style depends on which database driver is being used.
  670.      *
  671.      * MySQL can't handle the backtick character (<kbd>`</kbd>) in
  672.      * table or column names.
  673.      *
  674.      * @param string $str  identifier name to be quoted
  675.      *
  676.      * @return string  quoted identifier string
  677.      *
  678.      * @since 1.6.0
  679.      * @access public
  680.      * @internal
  681.      */
  682.     function quoteIdentifier($str)
  683.     {
  684.         return '`' . $str . '`';
  685.     }
  686.  
  687.     // }}}
  688.     // {{{ quote()
  689.  
  690.     /**
  691.      * @deprecated  Deprecated in release 1.6.0
  692.      * @internal
  693.      */
  694.     function quote($str) {
  695.         return $this->quoteSmart($str);
  696.     }
  697.  
  698.     // }}}
  699.     // {{{ escapeSimple()
  700.  
  701.     /**
  702.      * Escape a string according to the current DBMS's standards
  703.      *
  704.      * @param string $str  the string to be escaped
  705.      *
  706.      * @return string  the escaped string
  707.      *
  708.      * @internal
  709.      */
  710.     function escapeSimple($str) {
  711.         if (function_exists('mysql_real_escape_string')) {
  712.             return @mysql_real_escape_string($str, $this->connection);
  713.         } else {
  714.             return @mysql_escape_string($str);
  715.         }
  716.     }
  717.  
  718.     // }}}
  719.     // {{{ modifyQuery()
  720.  
  721.     function modifyQuery($query)
  722.     {
  723.         if ($this->options['portability'] & DB_PORTABILITY_DELETE_COUNT) {
  724.             // "DELETE FROM table" gives 0 affected rows in MySQL.
  725.             // This little hack lets you know how many rows were deleted.
  726.             if (preg_match('/^\s*DELETE\s+FROM\s+(\S+)\s*$/i', $query)) {
  727.                 $query = preg_replace('/^\s*DELETE\s+FROM\s+(\S+)\s*$/',
  728.                                       'DELETE FROM \1 WHERE 1=1', $query);
  729.             }
  730.         }
  731.         return $query;
  732.     }
  733.  
  734.     // }}}
  735.     // {{{ modifyLimitQuery()
  736.  
  737.     function modifyLimitQuery($query, $from, $count, $params = array())
  738.     {
  739.         if (DB::isManip($query)) {
  740.             return $query . " LIMIT $count";
  741.         } else {
  742.             return $query . " LIMIT $from, $count";
  743.         }
  744.     }
  745.  
  746.     // }}}
  747.     // {{{ mysqlRaiseError()
  748.  
  749.     /**
  750.      * Gather information about an error, then use that info to create a
  751.      * DB error object and finally return that object.
  752.      *
  753.      * @param  integer  $errno  PEAR error number (usually a DB constant) if
  754.      *                          manually raising an error
  755.      * @return object  DB error object
  756.      * @see DB_common::errorCode()
  757.      * @see DB_common::raiseError()
  758.      */
  759.     function mysqlRaiseError($errno = null)
  760.     {
  761.         if ($errno === null) {
  762.             if ($this->options['portability'] & DB_PORTABILITY_ERRORS) {
  763.                 $this->errorcode_map[1022] = DB_ERROR_CONSTRAINT;
  764.                 $this->errorcode_map[1048] = DB_ERROR_CONSTRAINT_NOT_NULL;
  765.                 $this->errorcode_map[1062] = DB_ERROR_CONSTRAINT;
  766.             } else {
  767.                 // Doing this in case mode changes during runtime.
  768.                 $this->errorcode_map[1022] = DB_ERROR_ALREADY_EXISTS;
  769.                 $this->errorcode_map[1048] = DB_ERROR_CONSTRAINT;
  770.                 $this->errorcode_map[1062] = DB_ERROR_ALREADY_EXISTS;
  771.             }
  772.             $errno = $this->errorCode(mysql_errno($this->connection));
  773.         }
  774.         return $this->raiseError($errno, null, null, null,
  775.                                  @mysql_errno($this->connection) . ' ** ' .
  776.                                  @mysql_error($this->connection));
  777.     }
  778.  
  779.     // }}}
  780.     // {{{ tableInfo()
  781.  
  782.     /**
  783.      * Returns information about a table or a result set.
  784.      *
  785.      * @param object|string  $result  DB_result object from a query or a
  786.      *                                string containing the name of a table
  787.      * @param int            $mode    a valid tableInfo mode
  788.      * @return array  an associative array with the information requested
  789.      *                or an error object if something is wrong
  790.      * @access public
  791.      * @internal
  792.      * @see DB_common::tableInfo()
  793.      */
  794.     function tableInfo($result, $mode = null) {
  795.         if (isset($result->result)) {
  796.             /*
  797.              * Probably received a result object.
  798.              * Extract the result resource identifier.
  799.              */
  800.             $id = $result->result;
  801.             $got_string = false;
  802.         } elseif (is_string($result)) {
  803.             /*
  804.              * Probably received a table name.
  805.              * Create a result resource identifier.
  806.              */
  807.             $id = @mysql_list_fields($this->dsn['database'],
  808.                                      $result, $this->connection);
  809.             $got_string = true;
  810.         } else {
  811.             /*
  812.              * Probably received a result resource identifier.
  813.              * Copy it.
  814.              * Deprecated.  Here for compatibility only.
  815.              */
  816.             $id = $result;
  817.             $got_string = false;
  818.         }
  819.  
  820.         if (!is_resource($id)) {
  821.             return $this->mysqlRaiseError(DB_ERROR_NEED_MORE_DATA);
  822.         }
  823.  
  824.         if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
  825.             $case_func = 'strtolower';
  826.         } else {
  827.             $case_func = 'strval';
  828.         }
  829.  
  830.         $count = @mysql_num_fields($id);
  831.  
  832.         // made this IF due to performance (one if is faster than $count if's)
  833.         if (!$mode) {
  834.             for ($i=0; $i<$count; $i++) {
  835.                 $res[$i]['table'] = $case_func(@mysql_field_table($id, $i));
  836.                 $res[$i]['name']  = $case_func(@mysql_field_name($id, $i));
  837.                 $res[$i]['type']  = @mysql_field_type($id, $i);
  838.                 $res[$i]['len']   = @mysql_field_len($id, $i);
  839.                 $res[$i]['flags'] = @mysql_field_flags($id, $i);
  840.             }
  841.         } else { // full
  842.             $res['num_fields']= $count;
  843.  
  844.             for ($i=0; $i<$count; $i++) {
  845.                 $res[$i]['table'] = $case_func(@mysql_field_table($id, $i));
  846.                 $res[$i]['name']  = $case_func(@mysql_field_name($id, $i));
  847.                 $res[$i]['type']  = @mysql_field_type($id, $i);
  848.                 $res[$i]['len']   = @mysql_field_len($id, $i);
  849.                 $res[$i]['flags'] = @mysql_field_flags($id, $i);
  850.  
  851.                 if ($mode & DB_TABLEINFO_ORDER) {
  852.                     $res['order'][$res[$i]['name']] = $i;
  853.                 }
  854.                 if ($mode & DB_TABLEINFO_ORDERTABLE) {
  855.                     $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
  856.                 }
  857.             }
  858.         }
  859.  
  860.         // free the result only if we were called on a table
  861.         if ($got_string) {
  862.             @mysql_free_result($id);
  863.         }
  864.         return $res;
  865.     }
  866.  
  867.     // }}}
  868.     // {{{ getSpecialQuery()
  869.  
  870.     /**
  871.      * Returns the query needed to get some backend info
  872.      * @param string $type What kind of info you want to retrieve
  873.      * @return string The SQL query string
  874.      */
  875.     function getSpecialQuery($type)
  876.     {
  877.         switch ($type) {
  878.             case 'tables':
  879.                 return 'SHOW TABLES';
  880.             case 'views':
  881.                 return DB_ERROR_NOT_CAPABLE;
  882.             case 'users':
  883.                 $sql = 'select distinct User from user';
  884.                 if ($this->dsn['database'] != 'mysql') {
  885.                     $dsn = $this->dsn;
  886.                     $dsn['database'] = 'mysql';
  887.                     if (DB::isError($db = DB::connect($dsn))) {
  888.                         return $db;
  889.                     }
  890.                     $sql = $db->getCol($sql);
  891.                     $db->disconnect();
  892.                     // XXX Fixme the mysql driver should take care of this
  893.                     if (!@mysql_select_db($this->dsn['database'], $this->connection)) {
  894.                         return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
  895.                     }
  896.                 }
  897.                 return $sql;
  898.             case 'databases':
  899.                 return 'SHOW DATABASES';
  900.             default:
  901.                 return null;
  902.         }
  903.     }
  904.  
  905.     // }}}
  906.  
  907. }
  908.  
  909. /*
  910.  * Local variables:
  911.  * tab-width: 4
  912.  * c-basic-offset: 4
  913.  * End:
  914.  */
  915.  
  916. ?>
  917.